/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

/* ****************************************************************
 ******************************************************************
 ******************************************************************
 *** COPYRIGHT (c) Eastman Kodak Company, 1997
 *** As  an unpublished  work pursuant to Title 17 of the United
 *** States Code.  All rights reserved.
 ******************************************************************
 ******************************************************************
 ******************************************************************/

package java.awt.image;

/**
 * This class represents image data which is stored in a band interleaved
 * fashion and for
 * which each sample of a pixel occupies one data element of the DataBuffer.
 * It subclasses ComponentSampleModel but provides a more efficient
 * implementation for accessing band interleaved image data than is provided
 * by ComponentSampleModel.  This class should typically be used when working
 * with images which store sample data for each band in a different bank of the
 * DataBuffer. Accessor methods are provided so that image data can be
 * manipulated directly. Pixel stride is the number of
 * data array elements between two samples for the same band on the same
 * scanline. The pixel stride for a BandedSampleModel is one.
 * Scanline stride is the number of data array elements between
 * a given sample and the corresponding sample in the same column of the next
 * scanline.  Band offsets denote the number
 * of data array elements from the first data array element of the bank
 * of the DataBuffer holding each band to the first sample of the band.
 * The bands are numbered from 0 to N-1.
 * Bank indices denote the correspondence between a bank of the data buffer
 * and a band of image data.  This class supports
 * {@link DataBuffer#TYPE_BYTE TYPE_BYTE},
 * {@link DataBuffer#TYPE_USHORT TYPE_USHORT},
 * {@link DataBuffer#TYPE_SHORT TYPE_SHORT},
 * {@link DataBuffer#TYPE_INT TYPE_INT},
 * {@link DataBuffer#TYPE_FLOAT TYPE_FLOAT}, and
 * {@link DataBuffer#TYPE_DOUBLE TYPE_DOUBLE} datatypes
 */


public final class BandedSampleModel extends ComponentSampleModel {

  /**
   * Constructs a BandedSampleModel with the specified parameters.
   * The pixel stride will be one data element.  The scanline stride
   * will be the same as the width.  Each band will be stored in
   * a separate bank and all band offsets will be zero.
   *
   * @param dataType The data type for storing samples.
   * @param w The width (in pixels) of the region of image data described.
   * @param h The height (in pixels) of the region of image data described.
   * @param numBands The number of bands for the image data.
   * @throws IllegalArgumentException if <code>dataType</code> is not one of the supported data
   * types
   */
  public BandedSampleModel(int dataType, int w, int h, int numBands) {
    super(dataType, w, h, 1, w,
        BandedSampleModel.createIndicesArray(numBands),
        BandedSampleModel.createOffsetArray(numBands));
  }

  /**
   * Constructs a BandedSampleModel with the specified parameters.
   * The number of bands will be inferred from the lengths of the
   * bandOffsets bankIndices arrays, which must be equal.  The pixel
   * stride will be one data element.
   *
   * @param dataType The data type for storing samples.
   * @param w The width (in pixels) of the region of image data described.
   * @param h The height (in pixels) of the region of image data described.
   * @param scanlineStride The line stride of the of the image data.
   * @param bankIndices The bank index for each band.
   * @param bandOffsets The band offset for each band.
   * @throws IllegalArgumentException if <code>dataType</code> is not one of the supported data
   * types
   */
  public BandedSampleModel(int dataType,
      int w, int h,
      int scanlineStride,
      int bankIndices[],
      int bandOffsets[]) {

    super(dataType, w, h, 1, scanlineStride, bankIndices, bandOffsets);
  }

  /**
   * Creates a new BandedSampleModel with the specified
   * width and height.  The new BandedSampleModel will have the same
   * number of bands, storage data type, and bank indices
   * as this BandedSampleModel.  The band offsets will be compressed
   * such that the offset between bands will be w*pixelStride and
   * the minimum of all of the band offsets is zero.
   *
   * @param w the width of the resulting <code>BandedSampleModel</code>
   * @param h the height of the resulting <code>BandedSampleModel</code>
   * @return a new <code>BandedSampleModel</code> with the specified width and height.
   * @throws IllegalArgumentException if <code>w</code> or <code>h</code> equals either
   * <code>Integer.MAX_VALUE</code> or <code>Integer.MIN_VALUE</code>
   * @throws IllegalArgumentException if <code>dataType</code> is not one of the supported data
   * types
   */
  public SampleModel createCompatibleSampleModel(int w, int h) {
    int[] bandOffs;

    if (numBanks == 1) {
      bandOffs = orderBands(bandOffsets, w * h);
    } else {
      bandOffs = new int[bandOffsets.length];
    }

    SampleModel sampleModel =
        new BandedSampleModel(dataType, w, h, w, bankIndices, bandOffs);
    return sampleModel;
  }

  /**
   * Creates a new BandedSampleModel with a subset of the bands of this
   * BandedSampleModel.  The new BandedSampleModel can be
   * used with any DataBuffer that the existing BandedSampleModel
   * can be used with.  The new BandedSampleModel/DataBuffer
   * combination will represent an image with a subset of the bands
   * of the original BandedSampleModel/DataBuffer combination.
   *
   * @throws RasterFormatException if the number of bands is greater than the number of banks in
   * this sample model.
   * @throws IllegalArgumentException if <code>dataType</code> is not one of the supported data
   * types
   */
  public SampleModel createSubsetSampleModel(int bands[]) {
    if (bands.length > bankIndices.length) {
      throw new RasterFormatException("There are only " +
          bankIndices.length +
          " bands");
    }
    int newBankIndices[] = new int[bands.length];
    int newBandOffsets[] = new int[bands.length];

    for (int i = 0; i < bands.length; i++) {
      newBankIndices[i] = bankIndices[bands[i]];
      newBandOffsets[i] = bandOffsets[bands[i]];
    }

    return new BandedSampleModel(this.dataType, width, height,
        this.scanlineStride,
        newBankIndices, newBandOffsets);
  }

  /**
   * Creates a DataBuffer that corresponds to this BandedSampleModel,
   * The DataBuffer's data type, number of banks, and size
   * will be consistent with this BandedSampleModel.
   *
   * @throws IllegalArgumentException if <code>dataType</code> is not one of the supported types.
   */
  public DataBuffer createDataBuffer() {
    DataBuffer dataBuffer = null;

    int size = scanlineStride * height;
    switch (dataType) {
      case DataBuffer.TYPE_BYTE:
        dataBuffer = new DataBufferByte(size, numBanks);
        break;
      case DataBuffer.TYPE_USHORT:
        dataBuffer = new DataBufferUShort(size, numBanks);
        break;
      case DataBuffer.TYPE_SHORT:
        dataBuffer = new DataBufferShort(size, numBanks);
        break;
      case DataBuffer.TYPE_INT:
        dataBuffer = new DataBufferInt(size, numBanks);
        break;
      case DataBuffer.TYPE_FLOAT:
        dataBuffer = new DataBufferFloat(size, numBanks);
        break;
      case DataBuffer.TYPE_DOUBLE:
        dataBuffer = new DataBufferDouble(size, numBanks);
        break;
      default:
        throw new IllegalArgumentException("dataType is not one " +
            "of the supported types.");
    }

    return dataBuffer;
  }


  /**
   * Returns data for a single pixel in a primitive array of type
   * TransferType.  For a BandedSampleModel, this will be the same
   * as the data type, and samples will be returned one per array
   * element.  Generally, obj
   * should be passed in as null, so that the Object will be created
   * automatically and will be of the right primitive data type.
   * <p>
   * The following code illustrates transferring data for one pixel from
   * DataBuffer <code>db1</code>, whose storage layout is described by
   * BandedSampleModel <code>bsm1</code>, to DataBuffer <code>db2</code>,
   * whose storage layout is described by
   * BandedSampleModel <code>bsm2</code>.
   * The transfer will generally be more efficient than using
   * getPixel/setPixel.
   * <pre>
   *       BandedSampleModel bsm1, bsm2;
   *       DataBufferInt db1, db2;
   *       bsm2.setDataElements(x, y, bsm1.getDataElements(x, y, null, db1),
   *                            db2);
   * </pre>
   * Using getDataElements/setDataElements to transfer between two
   * DataBuffer/SampleModel pairs is legitimate if the SampleModels have
   * the same number of bands, corresponding bands have the same number of
   * bits per sample, and the TransferTypes are the same.
   * <p>
   * If obj is non-null, it should be a primitive array of type TransferType.
   * Otherwise, a ClassCastException is thrown.  An
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds, or if obj is non-null and is not large enough to hold
   * the pixel data.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param obj If non-null, a primitive array in which to return the pixel data.
   * @param data The DataBuffer containing the image data.
   * @return the data for the specified pixel.
   * @see #setDataElements(int, int, Object, DataBuffer)
   */
  public Object getDataElements(int x, int y, Object obj, DataBuffer data) {
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    int type = getTransferType();
    int numDataElems = getNumDataElements();
    int pixelOffset = y * scanlineStride + x;

    switch (type) {

      case DataBuffer.TYPE_BYTE:

        byte[] bdata;

        if (obj == null) {
          bdata = new byte[numDataElems];
        } else {
          bdata = (byte[]) obj;
        }

        for (int i = 0; i < numDataElems; i++) {
          bdata[i] = (byte) data.getElem(bankIndices[i],
              pixelOffset + bandOffsets[i]);
        }

        obj = (Object) bdata;
        break;

      case DataBuffer.TYPE_USHORT:
      case DataBuffer.TYPE_SHORT:

        short[] sdata;

        if (obj == null) {
          sdata = new short[numDataElems];
        } else {
          sdata = (short[]) obj;
        }

        for (int i = 0; i < numDataElems; i++) {
          sdata[i] = (short) data.getElem(bankIndices[i],
              pixelOffset + bandOffsets[i]);
        }

        obj = (Object) sdata;
        break;

      case DataBuffer.TYPE_INT:

        int[] idata;

        if (obj == null) {
          idata = new int[numDataElems];
        } else {
          idata = (int[]) obj;
        }

        for (int i = 0; i < numDataElems; i++) {
          idata[i] = data.getElem(bankIndices[i],
              pixelOffset + bandOffsets[i]);
        }

        obj = (Object) idata;
        break;

      case DataBuffer.TYPE_FLOAT:

        float[] fdata;

        if (obj == null) {
          fdata = new float[numDataElems];
        } else {
          fdata = (float[]) obj;
        }

        for (int i = 0; i < numDataElems; i++) {
          fdata[i] = data.getElemFloat(bankIndices[i],
              pixelOffset + bandOffsets[i]);
        }

        obj = (Object) fdata;
        break;

      case DataBuffer.TYPE_DOUBLE:

        double[] ddata;

        if (obj == null) {
          ddata = new double[numDataElems];
        } else {
          ddata = (double[]) obj;
        }

        for (int i = 0; i < numDataElems; i++) {
          ddata[i] = data.getElemDouble(bankIndices[i],
              pixelOffset + bandOffsets[i]);
        }

        obj = (Object) ddata;
        break;
    }

    return obj;
  }

  /**
   * Returns all samples for the specified pixel in an int array.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param iArray If non-null, returns the samples in this array
   * @param data The DataBuffer containing the image data
   * @return the samples for the specified pixel.
   * @see #setPixel(int, int, int[], DataBuffer)
   */
  public int[] getPixel(int x, int y, int iArray[], DataBuffer data) {
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }

    int[] pixels;

    if (iArray != null) {
      pixels = iArray;
    } else {
      pixels = new int[numBands];
    }

    int pixelOffset = y * scanlineStride + x;
    for (int i = 0; i < numBands; i++) {
      pixels[i] = data.getElem(bankIndices[i],
          pixelOffset + bandOffsets[i]);
    }
    return pixels;
  }

  /**
   * Returns all samples for the specified rectangle of pixels in
   * an int array, one sample per data array element.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the upper left pixel location
   * @param y The Y coordinate of the upper left pixel location
   * @param w The width of the pixel rectangle
   * @param h The height of the pixel rectangle
   * @param iArray If non-null, returns the samples in this array
   * @param data The DataBuffer containing the image data
   * @return the samples for the pixels within the specified region.
   * @see #setPixels(int, int, int, int, int[], DataBuffer)
   */
  public int[] getPixels(int x, int y, int w, int h,
      int iArray[], DataBuffer data) {
    int x1 = x + w;
    int y1 = y + h;

    if (x < 0 || x >= width || w > width || x1 < 0 || x1 > width ||
        y < 0 || y >= height || h > height || y1 < 0 || y1 > height) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    int[] pixels;

    if (iArray != null) {
      pixels = iArray;
    } else {
      pixels = new int[w * h * numBands];
    }

    for (int k = 0; k < numBands; k++) {
      int lineOffset = y * scanlineStride + x + bandOffsets[k];
      int srcOffset = k;
      int bank = bankIndices[k];

      for (int i = 0; i < h; i++) {
        int pixelOffset = lineOffset;
        for (int j = 0; j < w; j++) {
          pixels[srcOffset] = data.getElem(bank, pixelOffset++);
          srcOffset += numBands;
        }
        lineOffset += scanlineStride;
      }
    }
    return pixels;
  }

  /**
   * Returns as int the sample in a specified band for the pixel
   * located at (x,y).
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param b The band to return
   * @param data The DataBuffer containing the image data
   * @return the sample in the specified band for the specified pixel.
   * @see #setSample(int, int, int, int, DataBuffer)
   */
  public int getSample(int x, int y, int b, DataBuffer data) {
    // Bounds check for 'b' will be performed automatically
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    int sample =
        data.getElem(bankIndices[b],
            y * scanlineStride + x + bandOffsets[b]);
    return sample;
  }

  /**
   * Returns the sample in a specified band
   * for the pixel located at (x,y) as a float.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param b The band to return
   * @param data The DataBuffer containing the image data
   * @return a float value that represents the sample in the specified band for the specified pixel.
   */
  public float getSampleFloat(int x, int y, int b, DataBuffer data) {
    // Bounds check for 'b' will be performed automatically
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }

    float sample = data.getElemFloat(bankIndices[b],
        y * scanlineStride + x + bandOffsets[b]);
    return sample;
  }

  /**
   * Returns the sample in a specified band
   * for a pixel located at (x,y) as a double.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param b The band to return
   * @param data The DataBuffer containing the image data
   * @return a double value that represents the sample in the specified band for the specified
   * pixel.
   */
  public double getSampleDouble(int x, int y, int b, DataBuffer data) {
    // Bounds check for 'b' will be performed automatically
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }

    double sample = data.getElemDouble(bankIndices[b],
        y * scanlineStride + x + bandOffsets[b]);
    return sample;
  }

  /**
   * Returns the samples in a specified band for the specified rectangle
   * of pixels in an int array, one sample per data array element.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the upper left pixel location
   * @param y The Y coordinate of the upper left pixel location
   * @param w The width of the pixel rectangle
   * @param h The height of the pixel rectangle
   * @param b The band to return
   * @param iArray If non-null, returns the samples in this array
   * @param data The DataBuffer containing the image data
   * @return the samples in the specified band for the pixels within the specified region.
   * @see #setSamples(int, int, int, int, int, int[], DataBuffer)
   */
  public int[] getSamples(int x, int y, int w, int h, int b,
      int iArray[], DataBuffer data) {
    // Bounds check for 'b' will be performed automatically
    if ((x < 0) || (y < 0) || (x + w > width) || (y + h > height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    int samples[];
    if (iArray != null) {
      samples = iArray;
    } else {
      samples = new int[w * h];
    }

    int lineOffset = y * scanlineStride + x + bandOffsets[b];
    int srcOffset = 0;
    int bank = bankIndices[b];

    for (int i = 0; i < h; i++) {
      int sampleOffset = lineOffset;
      for (int j = 0; j < w; j++) {
        samples[srcOffset++] = data.getElem(bank, sampleOffset++);
      }
      lineOffset += scanlineStride;
    }
    return samples;
  }

  /**
   * Sets the data for a single pixel in the specified DataBuffer from a
   * primitive array of type TransferType.  For a BandedSampleModel,
   * this will be the same as the data type, and samples are transferred
   * one per array element.
   * <p>
   * The following code illustrates transferring data for one pixel from
   * DataBuffer <code>db1</code>, whose storage layout is described by
   * BandedSampleModel <code>bsm1</code>, to DataBuffer <code>db2</code>,
   * whose storage layout is described by
   * BandedSampleModel <code>bsm2</code>.
   * The transfer will generally be more efficient than using
   * getPixel/setPixel.
   * <pre>
   *       BandedSampleModel bsm1, bsm2;
   *       DataBufferInt db1, db2;
   *       bsm2.setDataElements(x, y, bsm1.getDataElements(x, y, null, db1),
   *                            db2);
   * </pre>
   * Using getDataElements/setDataElements to transfer between two
   * DataBuffer/SampleModel pairs is legitimate if the SampleModels have
   * the same number of bands, corresponding bands have the same number of
   * bits per sample, and the TransferTypes are the same.
   * <p>
   * obj must be a primitive array of type TransferType.  Otherwise,
   * a ClassCastException is thrown.  An
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds, or if obj is not large enough to hold the pixel data.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param obj If non-null, returns the primitive array in this object
   * @param data The DataBuffer containing the image data
   * @see #getDataElements(int, int, Object, DataBuffer)
   */
  public void setDataElements(int x, int y, Object obj, DataBuffer data) {
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    int type = getTransferType();
    int numDataElems = getNumDataElements();
    int pixelOffset = y * scanlineStride + x;

    switch (type) {

      case DataBuffer.TYPE_BYTE:

        byte[] barray = (byte[]) obj;

        for (int i = 0; i < numDataElems; i++) {
          data.setElem(bankIndices[i], pixelOffset + bandOffsets[i],
              barray[i] & 0xff);
        }
        break;

      case DataBuffer.TYPE_USHORT:
      case DataBuffer.TYPE_SHORT:

        short[] sarray = (short[]) obj;

        for (int i = 0; i < numDataElems; i++) {
          data.setElem(bankIndices[i], pixelOffset + bandOffsets[i],
              sarray[i] & 0xffff);
        }
        break;

      case DataBuffer.TYPE_INT:

        int[] iarray = (int[]) obj;

        for (int i = 0; i < numDataElems; i++) {
          data.setElem(bankIndices[i], pixelOffset + bandOffsets[i],
              iarray[i]);
        }
        break;

      case DataBuffer.TYPE_FLOAT:

        float[] farray = (float[]) obj;

        for (int i = 0; i < numDataElems; i++) {
          data.setElemFloat(bankIndices[i], pixelOffset + bandOffsets[i],
              farray[i]);
        }
        break;

      case DataBuffer.TYPE_DOUBLE:

        double[] darray = (double[]) obj;

        for (int i = 0; i < numDataElems; i++) {
          data.setElemDouble(bankIndices[i], pixelOffset + bandOffsets[i],
              darray[i]);
        }
        break;

    }
  }

  /**
   * Sets a pixel in the DataBuffer using an int array of samples for input.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param iArray The input samples in an int array
   * @param data The DataBuffer containing the image data
   * @see #getPixel(int, int, int[], DataBuffer)
   */
  public void setPixel(int x, int y, int iArray[], DataBuffer data) {
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    int pixelOffset = y * scanlineStride + x;
    for (int i = 0; i < numBands; i++) {
      data.setElem(bankIndices[i], pixelOffset + bandOffsets[i],
          iArray[i]);
    }
  }

  /**
   * Sets all samples for a rectangle of pixels from an int array containing
   * one sample per array element.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the upper left pixel location
   * @param y The Y coordinate of the upper left pixel location
   * @param w The width of the pixel rectangle
   * @param h The height of the pixel rectangle
   * @param iArray The input samples in an int array
   * @param data The DataBuffer containing the image data
   * @see #getPixels(int, int, int, int, int[], DataBuffer)
   */
  public void setPixels(int x, int y, int w, int h,
      int iArray[], DataBuffer data) {
    int x1 = x + w;
    int y1 = y + h;

    if (x < 0 || x >= width || w > width || x1 < 0 || x1 > width ||
        y < 0 || y >= height || h > height || y1 < 0 || y1 > height) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }

    for (int k = 0; k < numBands; k++) {
      int lineOffset = y * scanlineStride + x + bandOffsets[k];
      int srcOffset = k;
      int bank = bankIndices[k];

      for (int i = 0; i < h; i++) {
        int pixelOffset = lineOffset;
        for (int j = 0; j < w; j++) {
          data.setElem(bank, pixelOffset++, iArray[srcOffset]);
          srcOffset += numBands;
        }
        lineOffset += scanlineStride;
      }
    }
  }

  /**
   * Sets a sample in the specified band for the pixel located at (x,y)
   * in the DataBuffer using an int for input.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param b The band to set
   * @param s The input sample as an int
   * @param data The DataBuffer containing the image data
   * @see #getSample(int, int, int, DataBuffer)
   */
  public void setSample(int x, int y, int b, int s,
      DataBuffer data) {
    // Bounds check for 'b' will be performed automatically
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    data.setElem(bankIndices[b],
        y * scanlineStride + x + bandOffsets[b], s);
  }

  /**
   * Sets a sample in the specified band for the pixel located at (x,y)
   * in the DataBuffer using a float for input.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param b The band to set
   * @param s The input sample as a float
   * @param data The DataBuffer containing the image data
   * @see #getSample(int, int, int, DataBuffer)
   */
  public void setSample(int x, int y, int b,
      float s,
      DataBuffer data) {
    // Bounds check for 'b' will be performed automatically
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    data.setElemFloat(bankIndices[b],
        y * scanlineStride + x + bandOffsets[b], s);
  }

  /**
   * Sets a sample in the specified band for the pixel located at (x,y)
   * in the DataBuffer using a double for input.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the pixel location
   * @param y The Y coordinate of the pixel location
   * @param b The band to set
   * @param s The input sample as a double
   * @param data The DataBuffer containing the image data
   * @see #getSample(int, int, int, DataBuffer)
   */
  public void setSample(int x, int y, int b,
      double s,
      DataBuffer data) {
    // Bounds check for 'b' will be performed automatically
    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    data.setElemDouble(bankIndices[b],
        y * scanlineStride + x + bandOffsets[b], s);
  }

  /**
   * Sets the samples in the specified band for the specified rectangle
   * of pixels from an int array containing one sample per data array element.
   * ArrayIndexOutOfBoundsException may be thrown if the coordinates are
   * not in bounds.
   *
   * @param x The X coordinate of the upper left pixel location
   * @param y The Y coordinate of the upper left pixel location
   * @param w The width of the pixel rectangle
   * @param h The height of the pixel rectangle
   * @param b The band to set
   * @param iArray The input sample array
   * @param data The DataBuffer containing the image data
   * @see #getSamples(int, int, int, int, int, int[], DataBuffer)
   */
  public void setSamples(int x, int y, int w, int h, int b,
      int iArray[], DataBuffer data) {
    // Bounds check for 'b' will be performed automatically
    if ((x < 0) || (y < 0) || (x + w > width) || (y + h > height)) {
      throw new ArrayIndexOutOfBoundsException
          ("Coordinate out of bounds!");
    }
    int lineOffset = y * scanlineStride + x + bandOffsets[b];
    int srcOffset = 0;
    int bank = bankIndices[b];

    for (int i = 0; i < h; i++) {
      int sampleOffset = lineOffset;
      for (int j = 0; j < w; j++) {
        data.setElem(bank, sampleOffset++, iArray[srcOffset++]);
      }
      lineOffset += scanlineStride;
    }
  }

  private static int[] createOffsetArray(int numBands) {
    int[] bandOffsets = new int[numBands];
    for (int i = 0; i < numBands; i++) {
      bandOffsets[i] = 0;
    }
    return bandOffsets;
  }

  private static int[] createIndicesArray(int numBands) {
    int[] bankIndices = new int[numBands];
    for (int i = 0; i < numBands; i++) {
      bankIndices[i] = i;
    }
    return bankIndices;
  }

  // Differentiate hash code from other ComponentSampleModel subclasses
  public int hashCode() {
    return super.hashCode() ^ 0x2;
  }
}
